{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp data.external"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai.torch_basics import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# External data\n",
    "> Helper functions to download the fastai datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A complete list of datasets that are available by default inside the library are: \n",
    "\n",
    "**Main datasets**:\n",
    "1.    **ADULT_SAMPLE**: A small of the [adults dataset](https://archive.ics.uci.edu/ml/datasets/Adult) to  predict whether income exceeds $50K/yr based on census data. \n",
    "-    **BIWI_SAMPLE**: A [BIWI kinect headpose database](https://www.kaggle.com/kmader/biwi-kinect-head-pose-database). The dataset contains over 15K images of 20 people (6 females and 14 males - 4 people were recorded twice). For each frame, a depth image, the corresponding rgb image (both 640x480 pixels), and the annotation is provided. The head pose range covers about +-75 degrees yaw and +-60 degrees pitch. \n",
    "1.    **CIFAR**: The famous [cifar-10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset which consists of 60000 32x32 colour images in 10 classes, with 6000 images per class.      \n",
    "1.    **COCO_SAMPLE**: A sample of the [coco dataset](http://cocodataset.org/#home) for object detection. \n",
    "1.    **COCO_TINY**: A tiny version of the [coco dataset](http://cocodataset.org/#home) for object detection.\n",
    "-    **HUMAN_NUMBERS**: A synthetic dataset consisting of human number counts in text such as one, two, three, four.. Useful for experimenting with Language Models.\n",
    "-    **IMDB**: The full [IMDB sentiment analysis dataset](https://ai.stanford.edu/~amaas/data/sentiment/).          \n",
    "\n",
    "-    **IMDB_SAMPLE**: A sample of the full [IMDB sentiment analysis dataset](https://ai.stanford.edu/~amaas/data/sentiment/). \n",
    "-    **ML_SAMPLE**: A movielens sample dataset for recommendation engines to recommend movies to users.            \n",
    "-    **ML_100k**: The movielens 100k dataset for recommendation engines to recommend movies to users.             \n",
    "-    **MNIST_SAMPLE**: A sample of the famous [MNIST dataset](http://yann.lecun.com/exdb/mnist/) consisting of handwritten digits.        \n",
    "-    **MNIST_TINY**: A tiny version of the famous [MNIST dataset](http://yann.lecun.com/exdb/mnist/) consisting of handwritten digits.                   \n",
    "-    **MNIST_VAR_SIZE_TINY**:  \n",
    "-    **PLANET_SAMPLE**: A sample of the planets dataset from the Kaggle competition [Planet: Understanding the Amazon from Space](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space).\n",
    "-    **PLANET_TINY**: A tiny version  of the planets dataset from the Kaggle competition [Planet: Understanding the Amazon from Space](https://www.kaggle.com/c/planet-understanding-the-amazon-from-space) for faster experimentation and prototyping.\n",
    "-    **IMAGENETTE**: A smaller version of the [imagenet dataset](http://www.image-net.org/) pronounced just like 'Imagenet', except with a corny inauthentic French accent. \n",
    "-    **IMAGENETTE_160**: The 160px version of the Imagenette dataset.      \n",
    "-    **IMAGENETTE_320**: The 320px version of the Imagenette dataset. \n",
    "-    **IMAGEWOOF**: Imagewoof is a subset of 10 classes from Imagenet that aren't so easy to classify, since they're all dog breeds.\n",
    "-    **IMAGEWOOF_160**: 160px version of the ImageWoof dataset.        \n",
    "-    **IMAGEWOOF_320**: 320px version of the ImageWoof dataset.\n",
    "-    **IMAGEWANG**: Imagewang contains Imagenette and Imagewoof combined, but with some twists that make it into a tricky semi-supervised unbalanced classification problem\n",
    "-    **IMAGEWANG_160**: 160px version of Imagewang.        \n",
    "-    **IMAGEWANG_320**: 320px version of Imagewang. \n",
    "\n",
    "**Kaggle competition datasets**:\n",
    "1. **DOGS**: Image dataset consisting of dogs and cats images from [Dogs vs Cats kaggle competition](https://www.kaggle.com/c/dogs-vs-cats). \n",
    "\n",
    "**Image Classification datasets**:\n",
    "1.    **CALTECH_101**: Pictures of objects belonging to 101 categories. About 40 to 800 images per category. Most categories have about 50 images. Collected in September 2003 by Fei-Fei Li, Marco Andreetto, and Marc 'Aurelio Ranzato.\n",
    "1.    CARS: The [Cars dataset](https://ai.stanford.edu/~jkrause/cars/car_dataset.html) contains 16,185 images of 196 classes of cars.   \n",
    "1.    **CIFAR_100**: The CIFAR-100 dataset consists of 60000 32x32 colour images in 100 classes, with 600 images per class.   \n",
    "1.    **CUB_200_2011**: Caltech-UCSD Birds-200-2011 (CUB-200-2011) is an extended version of the CUB-200 dataset, with roughly double the number of images per class and new part location annotations\n",
    "1.    **FLOWERS**: 17 category [flower dataset](http://www.robots.ox.ac.uk/~vgg/data/flowers/) by gathering images from various websites.\n",
    "1.    **FOOD**:         \n",
    "1.    **MNIST**: [MNIST dataset](http://yann.lecun.com/exdb/mnist/) consisting of handwritten digits.      \n",
    "1.    **PETS**: A 37 category [pet dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/) with roughly 200 images for each class.\n",
    "\n",
    "**NLP datasets**:\n",
    "1.    **AG_NEWS**: The AG News corpus consists of news articles from the AG’s corpus of news articles on the web pertaining to the 4 largest classes. The dataset contains 30,000 training and 1,900 testing examples for each class.\n",
    "1.    **AMAZON_REVIEWS**: This dataset contains product reviews and metadata from Amazon, including 142.8 million reviews spanning May 1996 - July 2014.\n",
    "1.    **AMAZON_REVIEWS_POLARITY**: Amazon reviews dataset for sentiment analysis.\n",
    "1.    **DBPEDIA**: The DBpedia ontology dataset contains 560,000 training samples and 70,000 testing samples for each of 14 nonoverlapping classes from DBpedia. \n",
    "1.    **MT_ENG_FRA**: Machine translation dataset from English to French.\n",
    "1.    **SOGOU_NEWS**: [The Sogou-SRR](http://www.thuir.cn/data-srr/) (Search Result Relevance) dataset was constructed to support researches on search engine relevance estimation and ranking tasks.\n",
    "1.    **WIKITEXT**: The [WikiText language modeling dataset](https://blog.einstein.ai/the-wikitext-long-term-dependency-language-modeling-dataset/) is a collection of over 100 million tokens extracted from the set of verified Good and Featured articles on Wikipedia.  \n",
    "1.    **WIKITEXT_TINY**: A tiny version of the WIKITEXT dataset.\n",
    "1.    **YAHOO_ANSWERS**: YAHOO's question answers dataset.\n",
    "1.    **YELP_REVIEWS**: The [Yelp dataset](https://www.yelp.com/dataset) is a subset of YELP businesses, reviews, and user data for use in personal, educational, and academic purposes\n",
    "1.    **YELP_REVIEWS_POLARITY**: For sentiment classification on YELP reviews.\n",
    "\n",
    "\n",
    "**Image localization datasets**:\n",
    "1.    **BIWI_HEAD_POSE**: A [BIWI kinect headpose database](https://www.kaggle.com/kmader/biwi-kinect-head-pose-database). The dataset contains over 15K images of 20 people (6 females and 14 males - 4 people were recorded twice). For each frame, a depth image, the corresponding rgb image (both 640x480 pixels), and the annotation is provided. The head pose range covers about +-75 degrees yaw and +-60 degrees pitch. \n",
    "1.    **CAMVID**: Consists of driving labelled dataset for segmentation type models.\n",
    "1.    **CAMVID_TINY**: A tiny camvid dataset for segmentation type models.\n",
    "1.    **LSUN_BEDROOMS**: [Large-scale Image Dataset](https://arxiv.org/abs/1506.03365) using Deep Learning with Humans in the Loop\n",
    "1.    **PASCAL_2007**: [Pascal 2007 dataset](http://host.robots.ox.ac.uk/pascal/VOC/voc2007/) to recognize objects from a number of visual object classes in realistic scenes.\n",
    "1.    **PASCAL_2012**: [Pascal 2012 dataset](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/) to recognize objects from a number of visual object classes in realistic scenes.\n",
    "\n",
    "**Audio classification**:\n",
    "1. **MACAQUES**: [7285 macaque coo calls](https://datadryad.org/stash/dataset/doi:10.5061/dryad.7f4p9) across 8 individuals from [Distributed acoustic cues for caller identity in macaque vocalization](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4806230).\n",
    "2. **ZEBRA_FINCH**: [3405 zebra finch calls](https://ndownloader.figshare.com/articles/11905533/versions/1) classified [across 11 call types](https://link.springer.com/article/10.1007/s10071-015-0933-6). Additional labels include name of individual making the vocalization and its age.\n",
    "\n",
    "**Medical Imaging datasets**:\n",
    "1. **SIIM_SMALL**: A smaller version of the [SIIM dataset](https://www.kaggle.com/c/siim-acr-pneumothorax-segmentation/overview) where the objective is to classify pneumothorax from a set of chest radiographic images.\n",
    "\n",
    "**Pretrained models**:\n",
    "1.    **OPENAI_TRANSFORMER**: The GPT2 Transformer pretrained weights.\n",
    "1.    **WT103_FWD**: The WikiText-103 forward language model weights.\n",
    "1.    **WT103_BWD**: The WikiText-103 backward language model weights."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To download any of the datasets or pretrained weights, simply run `untar_data` by passing any dataset name mentioned above like so: \n",
    "\n",
    "```python \n",
    "path = untar_data(URLs.PETS)\n",
    "path.ls()\n",
    "\n",
    ">> (#7393) [Path('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/keeshond_34.jpg'),...]\n",
    "```\n",
    "\n",
    "To download model pretrained weights: \n",
    "```python \n",
    "path = untar_data(URLs.PETS)\n",
    "path.ls()\n",
    "\n",
    ">> (#2) [Path('/home/ubuntu/.fastai/data/wt103-bwd/itos_wt103.pkl'),Path('/home/ubuntu/.fastai/data/wt103-bwd/lstm_bwd.pth')]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Config -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class Config:\n",
    "    \"Setup config at `~/.fastai` unless it exists already.\"\n",
    "    config_path = Path(os.getenv('FASTAI_HOME', '~/.fastai')).expanduser()\n",
    "    config_file = config_path/'config.yml'\n",
    "\n",
    "    def __init__(self):\n",
    "        self.config_path.mkdir(parents=True, exist_ok=True)\n",
    "        if not self.config_file.exists(): self.create_config()\n",
    "        self.d = self.load_config()\n",
    "\n",
    "    def __getitem__(self,k):\n",
    "        k = k.lower()\n",
    "        if k not in self.d: k = k+'_path'\n",
    "        return Path(self.d[k])\n",
    "\n",
    "    def __getattr__(self,k):\n",
    "        if k=='d': raise AttributeError\n",
    "        return self[k]\n",
    "\n",
    "    def __setitem__(self,k,v): self.d[k] = str(v)\n",
    "    def __contains__(self,k): return k in self.d\n",
    "\n",
    "    def load_config(self):\n",
    "        \"load and return config if version equals 2 in existing, else create new config.\"\n",
    "        with open(self.config_file, 'r') as f:\n",
    "            config = yaml.safe_load(f)\n",
    "            if 'version' in config and config['version'] == 2: return config\n",
    "            elif 'version' in config: self.create_config(config)\n",
    "            else: self.create_config()\n",
    "        return self.load_config()\n",
    "\n",
    "    def create_config(self, cfg=None):\n",
    "        \"create new config with default paths and set `version` to 2.\"\n",
    "        config = {'data_path':    str(self.config_path/'data'),\n",
    "                  'archive_path': str(self.config_path/'archive'),\n",
    "                  'storage_path': '/tmp',\n",
    "                  'model_path':   str(self.config_path/'models'),\n",
    "                  'version':      2}\n",
    "        if cfg is not None:\n",
    "            cfg['version'] = 2\n",
    "            config = merge(config, cfg)\n",
    "        self.save_file(config)\n",
    "\n",
    "    def save(self): self.save_file(self.d)\n",
    "    def save_file(self, config):\n",
    "        \"save config file at default config location `~/.fastai/config.yml`.\"\n",
    "        with self.config_file.open('w') as f: yaml.dump(config, f, default_flow_style=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a config file doesn't exist already, it is always created at `~/.fastai/config.yml` location by default whenever an instance of the `Config` class is created. Here is a quick example to explain: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "config_file = Path(\"~/.fastai/config.yml\").expanduser()\n",
    "if config_file.exists(): os.remove(config_file)\n",
    "assert not config_file.exists()\n",
    "\n",
    "config = Config()\n",
    "assert config_file.exists()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The config is now available as `config.d`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_path': '/home/jhoward/.fastai/archive',\n",
       " 'data_path': '/home/jhoward/.fastai/data',\n",
       " 'model_path': '/home/jhoward/.fastai/models',\n",
       " 'storage_path': '/tmp',\n",
       " 'version': 2}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config.d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen, this is a basic config file that consists of `data_path`, `model_path`, `storage_path` and `archive_path`. \n",
    "All future downloads occur at the paths defined in the config file based on the type of download. For example, all future fastai datasets are downloaded to the `data_path` while all pretrained model weights are download to `model_path` unless the default download location is updated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Path('/home/jhoward/.fastai/config.yml'),\n",
       " Path('/home/jhoward/.fastai/config.yml.bak'))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "config = Config()\n",
    "config_path = config.config_path\n",
    "config_file,config_bak = config_path/'config.yml',config_path/'config.yml.bak'\n",
    "config_file,config_bak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#This cell is just to make the config file compatible with current fastai\n",
    "# TODO: make this a method that auto-runs as needed\n",
    "if 'data_archive_path' not in config:\n",
    "    config['data_archive_path'] = config.data_path\n",
    "    config.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note that it is possible to update the default path locations in the config file. Let's first create a backup of the config file, then update the config to show the changes and re update the new config with the backup file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if config_file.exists(): shutil.move(config_file, config_bak)\n",
    "config['archive_path'] = Path(\".\")\n",
    "config.save()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_path': '.',\n",
       " 'data_archive_path': '/home/jhoward/.fastai/data',\n",
       " 'data_path': '/home/jhoward/.fastai/data',\n",
       " 'model_path': '/home/jhoward/.fastai/models',\n",
       " 'storage_path': '/tmp',\n",
       " 'version': 2}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config = Config()\n",
    "config.d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `archive_path` has been updated to `\".\"`. Now let's remove any updates we made to Config file that we made for the purpose of this example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'archive_path': '/home/jhoward/.fastai/archive',\n",
       " 'data_archive_path': '/home/jhoward/.fastai/data',\n",
       " 'data_path': '/home/jhoward/.fastai/data',\n",
       " 'model_path': '/home/jhoward/.fastai/models',\n",
       " 'storage_path': '/tmp',\n",
       " 'version': 2}"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if config_bak.exists(): shutil.move(config_bak, config_file)\n",
    "config = Config()\n",
    "config.d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## URLs -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class URLs():\n",
    "    \"Global constants for dataset and model URLs.\"\n",
    "    LOCAL_PATH = Path.cwd()\n",
    "    MDL = 'http://files.fast.ai/models/'\n",
    "    S3  = 'https://s3.amazonaws.com/fast-ai-'\n",
    "    URL = f'{S3}sample/'\n",
    "\n",
    "    S3_IMAGE    = f'{S3}imageclas/'\n",
    "    S3_IMAGELOC = f'{S3}imagelocal/'\n",
    "    S3_AUDI     = f'{S3}audio/'\n",
    "    S3_NLP      = f'{S3}nlp/'\n",
    "    S3_COCO     = f'{S3}coco/'\n",
    "    S3_MODEL    = f'{S3}modelzoo/'\n",
    "\n",
    "    # main datasets\n",
    "    ADULT_SAMPLE        = f'{URL}adult_sample.tgz'\n",
    "    BIWI_SAMPLE         = f'{URL}biwi_sample.tgz'\n",
    "    CIFAR               = f'{URL}cifar10.tgz'\n",
    "    COCO_SAMPLE         = f'{S3_COCO}coco_sample.tgz'\n",
    "    COCO_TINY           = f'{S3_COCO}coco_tiny.tgz'\n",
    "    HUMAN_NUMBERS       = f'{URL}human_numbers.tgz'\n",
    "    IMDB                = f'{S3_NLP}imdb.tgz'\n",
    "    IMDB_SAMPLE         = f'{URL}imdb_sample.tgz'\n",
    "    ML_SAMPLE           = f'{URL}movie_lens_sample.tgz'\n",
    "    ML_100k             = 'http://files.grouplens.org/datasets/movielens/ml-100k.zip'\n",
    "    MNIST_SAMPLE        = f'{URL}mnist_sample.tgz'\n",
    "    MNIST_TINY          = f'{URL}mnist_tiny.tgz'\n",
    "    MNIST_VAR_SIZE_TINY = f'{S3_IMAGE}mnist_var_size_tiny.tgz'\n",
    "    PLANET_SAMPLE       = f'{URL}planet_sample.tgz'\n",
    "    PLANET_TINY         = f'{URL}planet_tiny.tgz'\n",
    "    IMAGENETTE          = f'{S3_IMAGE}imagenette2.tgz'\n",
    "    IMAGENETTE_160      = f'{S3_IMAGE}imagenette2-160.tgz'\n",
    "    IMAGENETTE_320      = f'{S3_IMAGE}imagenette2-320.tgz'\n",
    "    IMAGEWOOF           = f'{S3_IMAGE}imagewoof2.tgz'\n",
    "    IMAGEWOOF_160       = f'{S3_IMAGE}imagewoof2-160.tgz'\n",
    "    IMAGEWOOF_320       = f'{S3_IMAGE}imagewoof2-320.tgz'\n",
    "    IMAGEWANG           = f'{S3_IMAGE}imagewang.tgz'\n",
    "    IMAGEWANG_160       = f'{S3_IMAGE}imagewang-160.tgz'\n",
    "    IMAGEWANG_320       = f'{S3_IMAGE}imagewang-320.tgz'\n",
    "\n",
    "    # kaggle competitions download dogs-vs-cats -p {DOGS.absolute()}\n",
    "    DOGS = f'{URL}dogscats.tgz'\n",
    "\n",
    "    # image classification datasets\n",
    "    CALTECH_101  = f'{S3_IMAGE}caltech_101.tgz'\n",
    "    CARS         = f'{S3_IMAGE}stanford-cars.tgz'\n",
    "    CIFAR_100    = f'{S3_IMAGE}cifar100.tgz'\n",
    "    CUB_200_2011 = f'{S3_IMAGE}CUB_200_2011.tgz'\n",
    "    FLOWERS      = f'{S3_IMAGE}oxford-102-flowers.tgz'\n",
    "    FOOD         = f'{S3_IMAGE}food-101.tgz'\n",
    "    MNIST        = f'{S3_IMAGE}mnist_png.tgz'\n",
    "    PETS         = f'{S3_IMAGE}oxford-iiit-pet.tgz'\n",
    "\n",
    "    # NLP datasets\n",
    "    AG_NEWS                 = f'{S3_NLP}ag_news_csv.tgz'\n",
    "    AMAZON_REVIEWS          = f'{S3_NLP}amazon_review_full_csv.tgz'\n",
    "    AMAZON_REVIEWS_POLARITY = f'{S3_NLP}amazon_review_polarity_csv.tgz'\n",
    "    DBPEDIA                 = f'{S3_NLP}dbpedia_csv.tgz'\n",
    "    MT_ENG_FRA              = f'{S3_NLP}giga-fren.tgz'\n",
    "    SOGOU_NEWS              = f'{S3_NLP}sogou_news_csv.tgz'\n",
    "    WIKITEXT                = f'{S3_NLP}wikitext-103.tgz'\n",
    "    WIKITEXT_TINY           = f'{S3_NLP}wikitext-2.tgz'\n",
    "    YAHOO_ANSWERS           = f'{S3_NLP}yahoo_answers_csv.tgz'\n",
    "    YELP_REVIEWS            = f'{S3_NLP}yelp_review_full_csv.tgz'\n",
    "    YELP_REVIEWS_POLARITY   = f'{S3_NLP}yelp_review_polarity_csv.tgz'\n",
    "\n",
    "    # Image localization datasets\n",
    "    BIWI_HEAD_POSE     = f\"{S3_IMAGELOC}biwi_head_pose.tgz\"\n",
    "    CAMVID             = f'{S3_IMAGELOC}camvid.tgz'\n",
    "    CAMVID_TINY        = f'{URL}camvid_tiny.tgz'\n",
    "    LSUN_BEDROOMS      = f'{S3_IMAGE}bedroom.tgz'\n",
    "    PASCAL_2007        = f'{S3_IMAGELOC}pascal_2007.tgz'\n",
    "    PASCAL_2012        = f'{S3_IMAGELOC}pascal_2012.tgz'\n",
    "\n",
    "    # Audio classification datasets\n",
    "    MACAQUES           = 'https://storage.googleapis.com/ml-animal-sounds-datasets/macaques.zip'\n",
    "    ZEBRA_FINCH        = 'https://storage.googleapis.com/ml-animal-sounds-datasets/zebra_finch.zip'\n",
    "\n",
    "    # Medical Imaging datasets\n",
    "    #SKIN_LESION        = f'{S3_IMAGELOC}skin_lesion.tgz'\n",
    "    SIIM_SMALL         = f'{S3_IMAGELOC}siim_small.tgz'\n",
    "\n",
    "    #Pretrained models\n",
    "    OPENAI_TRANSFORMER = f'{S3_MODEL}transformer.tgz'\n",
    "    WT103_FWD          = f'{S3_MODEL}wt103-fwd.tgz'\n",
    "    WT103_BWD          = f'{S3_MODEL}wt103-bwd.tgz'\n",
    "\n",
    "    def path(url='.', c_key='archive'):\n",
    "        \"Return local path where to download based on `c_key`\"\n",
    "        fname = url.split('/')[-1]\n",
    "        local_path = URLs.LOCAL_PATH/('models' if c_key=='models' else 'data')/fname\n",
    "        if local_path.exists(): return local_path\n",
    "        return Config()[c_key]/fname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default local path is at `~/.fastai/archive/` but this can be updated by passing a different `c_key`. Note: `c_key` should be one of `'archive_path', 'data_archive_path', 'data_path', 'model_path', 'storage_path'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Path('/home/jhoward/.fastai/archive/oxford-iiit-pet.tgz')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = URLs.PETS\n",
    "local_path = URLs.path(url)\n",
    "test_eq(local_path.parent, Config()['archive']); \n",
    "local_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Path('/home/jhoward/.fastai/models/oxford-iiit-pet.tgz')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "local_path = URLs.path(url, c_key='model')\n",
    "test_eq(local_path.parent, Config()['model'])\n",
    "local_path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def download_url(url, dest, overwrite=False, pbar=None, show_progress=True, chunk_size=1024*1024,\n",
    "                 timeout=4, retries=5):\n",
    "    \"Download `url` to `dest` unless it exists and not `overwrite`\"\n",
    "    if os.path.exists(dest) and not overwrite: return\n",
    "\n",
    "    s = requests.Session()\n",
    "    s.mount('http://',requests.adapters.HTTPAdapter(max_retries=retries))\n",
    "    # additional line to identify as a firefox browser, see fastai/#2438\n",
    "    s.headers.update({'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:71.0) Gecko/20100101 Firefox/71.0'})\n",
    "    u = s.get(url, stream=True, timeout=timeout)\n",
    "    try: file_size = int(u.headers[\"Content-Length\"])\n",
    "    except: show_progress = False\n",
    "\n",
    "    with open(dest, 'wb') as f:\n",
    "        nbytes = 0\n",
    "        if show_progress: pbar = progress_bar(range(file_size), leave=False, parent=pbar)\n",
    "        try:\n",
    "            if show_progress: pbar.update(0)\n",
    "            for chunk in u.iter_content(chunk_size=chunk_size):\n",
    "                nbytes += len(chunk)\n",
    "                if show_progress: pbar.update(nbytes)\n",
    "                f.write(chunk)\n",
    "        except requests.exceptions.ConnectionError as e:\n",
    "            fname = url.split('/')[-1]\n",
    "            data_dir = dest.parent\n",
    "            print(f'\\n Download of {url} has failed after {retries} retries\\n'\n",
    "                  f' Fix the download manually:\\n'\n",
    "                  f'$ mkdir -p {data_dir}\\n'\n",
    "                  f'$ cd {data_dir}\\n'\n",
    "                  f'$ wget -c {url}\\n'\n",
    "                  f'$ tar xf {fname}\\n'\n",
    "                  f' And re-run your code once the download is successful\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `download_url` is a very handy function inside fastai! This function can be used to download any file from the internet to a location passed by `dest` argument of the function. It should not be confused, that this function can only be used to download fastai-files. That couldn't be further away from the truth. As an example, let's download the pets dataset from the actual source file: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fname = Path(\"./dog.jpg\")\n",
    "if fname.exists(): os.remove(fname)\n",
    "url = \"https://i.insider.com/569fdd9ac08a80bd448b7138?width=1100&format=jpeg&auto=webp\"\n",
    "download_url(url, fname)\n",
    "assert fname.exists()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's confirm that the file was indeed downloaded correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "im = Image.open(fname)\n",
    "plt.imshow(im);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen, the file has been downloaded to the local path provided in `dest` argument. Calling the function again doesn't trigger a download since the file is already there. This can be confirmed by checking that the last modified time of the file that is downloaded doesn't get updated. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if fname.exists(): last_modified_time = os.path.getmtime(fname)\n",
    "download_url(url, fname)\n",
    "test_eq(os.path.getmtime(fname), last_modified_time)\n",
    "if fname.exists(): os.remove(fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `download_url` function to download the pet's dataset straight from the source by simply passing `https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz` in `url`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def download_data(url, fname=None, c_key='archive', force_download=False):\n",
    "    \"Download `url` to `fname`.\"\n",
    "    fname = Path(fname or URLs.path(url, c_key=c_key))\n",
    "    fname.parent.mkdir(parents=True, exist_ok=True)\n",
    "    if not fname.exists() or force_download: download_url(url, fname, overwrite=force_download)\n",
    "    return fname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `download_data` is a convenience function and a wrapper outside `download_url` to download fastai files to the appropriate local path based on the `c_key`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If `fname` is None, it will default to the archive folder you have in your config file (or data, model if you specify a different `c_key`) followed by the last part of the url: for instance `URLs.MNIST_SAMPLE` is `http://files.fast.ai/data/examples/mnist_sample.tgz` and the default value for `fname` will be `~/.fastai/archive/mnist_sample.tgz`.\n",
    "\n",
    "If `force_download=True`, the file is alwayd downloaded. Otherwise, it's only when the file doesn't exists that the download is triggered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide\n",
    "try:\n",
    "    test_eq(download_data(URLs.MNIST_SAMPLE), config.archive/'mnist_sample.tgz')\n",
    "    test_eq(download_data(URLs.MNIST_TINY, fname=Path('mnist.tgz')), Path('mnist.tgz'))\n",
    "finally: Path('mnist.tgz').unlink()\n",
    "\n",
    "try:\n",
    "    tst_model = config.model/'mnist_tiny.tgz'\n",
    "    test_eq(download_data(URLs.MNIST_TINY, c_key='model'), tst_model)\n",
    "    os.remove(tst_model)\n",
    "finally:\n",
    "    if tst_model.exists(): tst_model.unlink()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check datasets -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from nbdev.imports import Config as NbdevConfig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "__file__ = NbdevConfig().lib_path/'data'/'external.py'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _get_check(url):\n",
    "    \"internal function to get the hash of the file at `url`.\"\n",
    "    checks = json.load(open(Path(__file__).parent/'checks.txt', 'r'))\n",
    "    return checks.get(url, '')\n",
    "\n",
    "def _check_file(fname):\n",
    "    \"internal function to get the hash of the local file at `fname`.\"\n",
    "    size = os.path.getsize(fname)\n",
    "    with open(fname, \"rb\") as f: hash_nb = hashlib.md5(f.read(2**20)).hexdigest()\n",
    "    return [size,hash_nb]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([3214948, '2dbc7ec6f9259b583af0072c55816a88'],\n",
       " [3214948, '2dbc7ec6f9259b583af0072c55816a88'])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide\n",
    "test_eq(_get_check(URLs.MNIST_SAMPLE), _check_file(URLs.path(URLs.MNIST_SAMPLE)))\n",
    "_get_check(URLs.MNIST_SAMPLE), _check_file(URLs.path(URLs.MNIST_SAMPLE))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _add_check(url, fname):\n",
    "    \"Internal function to update the internal check file with `url` and check on `fname`.\"\n",
    "    checks = json.load(open(Path(__file__).parent/'checks.txt', 'r'))\n",
    "    checks[url] = _check_file(fname)\n",
    "    json.dump(checks, open(Path(__file__).parent/'checks.txt', 'w'), indent=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def file_extract(fname, dest=None):\n",
    "    \"Extract `fname` to `dest` using `tarfile` or `zipfile`.\"\n",
    "    if dest is None: dest = Path(fname).parent\n",
    "    fname = str(fname)\n",
    "    if   fname.endswith('gz'):  tarfile.open(fname, 'r:gz').extractall(dest)\n",
    "    elif fname.endswith('zip'): zipfile.ZipFile(fname     ).extractall(dest)\n",
    "    else: raise Exception(f'Unrecognized archive: {fname}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`file_extract` is used by default in `untar_data` to decompress the downloaded file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _try_from_storage(dest, storage):\n",
    "    \"an internal function to create symbolic links for files from `storage` to `dest` if `storage` exists\"\n",
    "    if not storage.exists(): return\n",
    "    os.makedirs(dest, exist_ok=True)\n",
    "    for f in storage.glob('*'): os.symlink(f, dest/f.name, target_is_directory=f.is_dir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "with tempfile.TemporaryDirectory() as d:\n",
    "    with tempfile.TemporaryDirectory() as d2:\n",
    "        d,d2 = Path(d),Path(d2)\n",
    "        for k in ['a', 'b', 'c']: os.makedirs(d/k)\n",
    "        for k in ['d', 'e', 'f']: (d/k).touch()\n",
    "        _try_from_storage(d2, d)\n",
    "        for k in ['a', 'b', 'c']: \n",
    "            assert (d2/k).exists()\n",
    "            assert (d2/k).is_dir()\n",
    "        for k in ['d', 'e', 'f']: \n",
    "            assert (d2/k).exists()\n",
    "            assert (d2/k).is_file()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def newest_folder(path):\n",
    "    \"Return newest folder on path\"\n",
    "    list_of_paths = path.glob('*')\n",
    "    return max(list_of_paths, key=lambda p: p.stat().st_ctime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def rename_extracted(dest):\n",
    "    \"Rename file if different from dest\"\n",
    "    extracted = newest_folder(dest.parent)\n",
    "    if not (extracted.name == dest.name): extracted.rename(dest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "let's rename the untar/unzip data if dest name is different from fname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def untar_data(url, fname=None, dest=None, c_key='data', force_download=False, extract_func=file_extract):\n",
    "    \"Download `url` to `fname` if `dest` doesn't exist, and un-tgz or unzip to folder `dest`.\"\n",
    "    default_dest = URLs.path(url, c_key=c_key).with_suffix('')\n",
    "    dest = default_dest if dest is None else Path(dest)/default_dest.name\n",
    "    fname = Path(fname or URLs.path(url))\n",
    "    if fname.exists() and _get_check(url) and _check_file(fname) != _get_check(url):\n",
    "        print(\"A new version of this dataset is available, downloading...\")\n",
    "        force_download = True\n",
    "    if force_download:\n",
    "        if fname.exists(): os.remove(fname)\n",
    "        if dest.exists(): shutil.rmtree(dest)\n",
    "    if not dest.exists(): _try_from_storage(dest, URLs.path(url, c_key='storage').with_suffix(''))\n",
    "    if not dest.exists():\n",
    "        fname = download_data(url, fname=fname, c_key=c_key)\n",
    "        if _get_check(url) and _check_file(fname) != _get_check(url):\n",
    "            print(f\"File downloaded is broken. Remove {fname} and try again.\")\n",
    "        extract_func(fname, dest.parent)\n",
    "        rename_extracted(dest)\n",
    "    return dest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`untar_data` is a very powerful convenience function to download files from `url` to `dest`. The `url` can be a default `url` from the `URLs` class or a custom url. If `dest` is not passed, files are downloaded at the `default_dest` which defaults to `~/.fastai/data/`.\n",
    "\n",
    "This convenience function extracts the downloaded files to `dest` by default. In order, to simply download the files without extracting, pass the `noop` function as `extract_func`. \n",
    "\n",
    "Note, it is also possible to pass a custom `extract_func` to `untar_data` if the filetype doesn't end with `.tgz` or `.zip`. The `gzip` and `zip` files are supported by default and there is no need to pass custom `extract_func` for these type of files. \n",
    "\n",
    "Internally, if files are not available at `fname` location already which defaults to `~/.fastai/archive/`, the files get downloaded at `~/.fastai/archive` and are then extracted at `dest` location. If no `dest` is passed the `default_dest` to download the files is `~/.fastai/data`. If files are already available at the `fname` location but not available then a symbolic link is created for each file from `fname` location to `dest`.\n",
    "\n",
    "Also, if `force_download` is set to `True`, files are re downloaded even if they exist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tempfile import TemporaryDirectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_eq(untar_data(URLs.MNIST_SAMPLE), config.data/'mnist_sample')\n",
    "\n",
    "with TemporaryDirectory() as d:\n",
    "    d = Path(d)\n",
    "    dest = untar_data(URLs.MNIST_TINY, fname='mnist_tiny.tgz', dest=d, force_download=True)\n",
    "    assert Path('mnist_tiny.tgz').exists()\n",
    "    assert (d/'mnist_tiny').exists()\n",
    "    os.unlink('mnist_tiny.tgz')\n",
    "\n",
    "#Test c_key\n",
    "tst_model = config.model/'mnist_sample'\n",
    "test_eq(untar_data(URLs.MNIST_SAMPLE, c_key='model'), tst_model)\n",
    "assert not tst_model.with_suffix('.tgz').exists() #Archive wasn't downloaded in the models path\n",
    "assert (config.archive/'mnist_sample.tgz').exists() #Archive was downloaded there\n",
    "shutil.rmtree(tst_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes the extracted folder does not have the same name as the downloaded file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#test fname!=dest\n",
    "with TemporaryDirectory() as d:\n",
    "    d = Path(d)\n",
    "    untar_data(URLs.MNIST_TINY, fname='mnist_tiny.tgz', dest=d, force_download=True)\n",
    "    Path('mnist_tiny.tgz').rename('nims_tini.tgz')\n",
    "    p = Path('nims_tini.tgz')\n",
    "    dest = Path('nims_tini')\n",
    "    assert p.exists()\n",
    "    file_extract(p, dest.parent)\n",
    "    rename_extracted(dest)\n",
    "    p.unlink()\n",
    "    shutil.rmtree(dest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check all URLs are in the checks.txt file and match for downloaded archives\n",
    "_whitelist = \"MDL LOCAL_PATH URL WT103_BWD WT103_FWD\".split()\n",
    "checks = json.load(open(Path(__file__).parent/'checks.txt', 'r'))\n",
    "for d in dir(URLs): \n",
    "    if d.upper() == d and not d.startswith(\"S3\") and not d in _whitelist: \n",
    "        url = getattr(URLs, d)\n",
    "        assert url in checks,f\"\"\"{d} is not in the check file for all URLs.\n",
    "To fix this, you need to run the following code in this notebook before making a PR (there is a commented cell for this below):\n",
    "url = URLs.{d}\n",
    "untar_data(url, force_download=True)\n",
    "_add_check(url, URLs.path(url))\n",
    "\"\"\"\n",
    "        f = URLs.path(url)\n",
    "        if f.exists():\n",
    "            assert checks[url] == _check_file(f),f\"\"\"The log we have for {d} in checks does not match the actual archive.\n",
    "To fix this, you need to run the following code in this notebook before making a PR (there is a commented cell for this below):\n",
    "url = URLs.{d}\n",
    "_add_check(url, URLs.path(url))\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_torch_core.ipynb.\n",
      "Converted 01_layers.ipynb.\n",
      "Converted 02_data.load.ipynb.\n",
      "Converted 03_data.core.ipynb.\n",
      "Converted 04_data.external.ipynb.\n",
      "Converted 05_data.transforms.ipynb.\n",
      "Converted 06_data.block.ipynb.\n",
      "Converted 07_vision.core.ipynb.\n",
      "Converted 08_vision.data.ipynb.\n",
      "Converted 09_vision.augment.ipynb.\n",
      "Converted 09b_vision.utils.ipynb.\n",
      "Converted 09c_vision.widgets.ipynb.\n",
      "Converted 10_tutorial.pets.ipynb.\n",
      "Converted 11_vision.models.xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_callback.core.ipynb.\n",
      "Converted 13a_learner.ipynb.\n",
      "Converted 13b_metrics.ipynb.\n",
      "Converted 14_callback.schedule.ipynb.\n",
      "Converted 14a_callback.data.ipynb.\n",
      "Converted 15_callback.hook.ipynb.\n",
      "Converted 15a_vision.models.unet.ipynb.\n",
      "Converted 16_callback.progress.ipynb.\n",
      "Converted 17_callback.tracker.ipynb.\n",
      "Converted 18_callback.fp16.ipynb.\n",
      "Converted 18a_callback.training.ipynb.\n",
      "Converted 19_callback.mixup.ipynb.\n",
      "Converted 20_interpret.ipynb.\n",
      "Converted 20a_distributed.ipynb.\n",
      "Converted 21_vision.learner.ipynb.\n",
      "Converted 22_tutorial.imagenette.ipynb.\n",
      "Converted 23_tutorial.vision.ipynb.\n",
      "Converted 24_tutorial.siamese.ipynb.\n",
      "Converted 24_vision.gan.ipynb.\n",
      "Converted 30_text.core.ipynb.\n",
      "Converted 31_text.data.ipynb.\n",
      "Converted 32_text.models.awdlstm.ipynb.\n",
      "Converted 33_text.models.core.ipynb.\n",
      "Converted 34_callback.rnn.ipynb.\n",
      "Converted 35_tutorial.wikitext.ipynb.\n",
      "Converted 36_text.models.qrnn.ipynb.\n",
      "Converted 37_text.learner.ipynb.\n",
      "Converted 38_tutorial.text.ipynb.\n",
      "Converted 39_tutorial.transformers.ipynb.\n",
      "Converted 40_tabular.core.ipynb.\n",
      "Converted 41_tabular.data.ipynb.\n",
      "Converted 42_tabular.model.ipynb.\n",
      "Converted 43_tabular.learner.ipynb.\n",
      "Converted 44_tutorial.tabular.ipynb.\n",
      "Converted 45_collab.ipynb.\n",
      "Converted 46_tutorial.collab.ipynb.\n",
      "Converted 50_tutorial.datablock.ipynb.\n",
      "Converted 60_medical.imaging.ipynb.\n",
      "Converted 61_tutorial.medical_imaging.ipynb.\n",
      "Converted 65_medical.text.ipynb.\n",
      "Converted 70_callback.wandb.ipynb.\n",
      "Converted 71_callback.tensorboard.ipynb.\n",
      "Converted 72_callback.neptune.ipynb.\n",
      "Converted 73_callback.captum.ipynb.\n",
      "Converted 74_callback.cutmix.ipynb.\n",
      "Converted 97_test_utils.ipynb.\n",
      "Converted 99_pytorch_doc.ipynb.\n",
      "Converted dev-setup.ipynb.\n",
      "Converted index.ipynb.\n",
      "Converted quick_start.ipynb.\n",
      "Converted tutorial.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
